21 september 2025Nederlands

Ontdek Python creational design patterns: Singleton, Factory, Abstract Factory, Builder en Prototype. Leer hun implementaties, voordelen en real-world toepassingen.

Python Design Patterns: Een Diepe Duik in Creational Patterns

Design patterns zijn herbruikbare oplossingen voor veelvoorkomende problemen in software design. Ze bieden een blauwdruk voor hoe deze problemen op te lossen, waardoor codeherbruikbaarheid, onderhoudbaarheid en flexibiliteit worden bevorderd. Creational design patterns, in het bijzonder, behandelen object creatie mechanismen, waarbij geprobeerd wordt objecten te creëren op een manier die geschikt is voor de situatie. Dit artikel biedt een uitgebreide verkenning van creational design patterns in Python, inclusief gedetailleerde uitleg, codevoorbeelden en praktische toepassingen relevant voor een wereldwijd publiek.

Wat zijn Creational Design Patterns?

Creational design patterns abstraheren het instantieproces. Ze ontkoppelen de client code van de specifieke klassen die worden geïnstantieerd, wat zorgt voor meer flexibiliteit en controle over object creatie. Door deze patronen te gebruiken, kunt u objecten maken zonder de exacte klasse van het te creëren object te specificeren. Deze scheiding van concerns maakt de code robuuster en gemakkelijker te onderhouden.

Het primaire doel van creational patterns is om het object instantieproces te abstraheren, waarbij de complexiteit van object creatie voor de client wordt verborgen. Dit stelt ontwikkelaars in staat zich te concentreren op de high-level logica van hun applicaties zonder te worden belemmerd door de details van object creatie.

Soorten Creational Design Patterns

We behandelen de volgende creational design patterns in dit artikel:

Singleton: Zorgt ervoor dat een klasse slechts één instantie heeft en biedt een globaal toegangspunt tot die instantie.
Factory Method: Definieert een interface voor het maken van een object, maar laat subclasses beslissen welke klasse moet worden geïnstantieerd.
Abstract Factory: Biedt een interface voor het creëren van families van gerelateerde of afhankelijke objecten zonder hun concrete klassen te specificeren.
Builder: Scheidt de constructie van een complex object van zijn representatie, waardoor hetzelfde constructieproces verschillende representaties kan creëren.
Prototype: Specificeert het soort objecten dat moet worden gemaakt met behulp van een prototypische instantie en creëert nieuwe objecten door dit prototype te kopiëren.

1. Singleton Pattern

Het Singleton pattern zorgt ervoor dat een klasse slechts één instantie heeft en biedt een globaal toegangspunt tot die instantie. Dit patroon is handig wanneer precies één object nodig is om acties in het hele systeem te coördineren. Het wordt vaak gebruikt voor het beheren van resources, logging of configuratie-instellingen.

Implementatie

Hier is een Python-implementatie van het Singleton pattern:

            
class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

# Voorbeeld gebruik
s1 = Singleton()
s2 = Singleton()

print(s1 is s2) # Output: True

Uitleg:

_instance: Deze klassevariabele slaat de enkele instantie van de klasse op.
__new__: Deze methode wordt aangeroepen vóór __init__ wanneer een object wordt gemaakt. Het controleert of er al een instantie bestaat. Zo niet, dan maakt het een nieuwe instantie met behulp van super().__new__(cls) en slaat deze op in _instance. Als er al een instantie bestaat, retourneert het de bestaande instantie.

Gebruiksscenario's

Database Connectie: Zorgen dat slechts één verbinding met een database tegelijkertijd open is.
Configuratiemanager: Een enkel toegangspunt bieden tot configuratie-instellingen van de applicatie.
Logger: Het creëren van een enkele logging instantie om alle logging bewerkingen in de applicatie af te handelen.

Voorbeeld

Laten we een eenvoudig voorbeeld bekijken van een configuratiemanager die is geïmplementeerd met behulp van het Singleton pattern:

            
class ConfigurationManager(Singleton):
    def __init__(self):
        if not hasattr(self, 'config'): # Zorg ervoor dat __init__ slechts één keer wordt aangeroepen
            self.config = {}

    def set_config(self, key, value):
        self.config[key] = value

    def get_config(self, key):
        return self.config.get(key)

# Voorbeeld gebruik
config_manager1 = ConfigurationManager()
config_manager1.set_config('database_url', 'localhost:5432')

config_manager2 = ConfigurationManager()
print(config_manager2.get_config('database_url')) # Output: localhost:5432

2. Factory Method Pattern

Het Factory Method pattern definieert een interface voor het maken van een object, maar laat subclasses beslissen welke klasse moet worden geïnstantieerd. Factory Method laat een klasse de instantie aan subclasses overlaten. Dit patroon bevordert losse koppeling en stelt u in staat om nieuwe producttypen toe te voegen zonder bestaande code te wijzigen.

Implementatie

Hier is een Python-implementatie van het Factory Method pattern:

            
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woef!"

class Cat(Animal):
    def speak(self):
        return "Miauw!"

class AnimalFactory(ABC):
    @abstractmethod
    def create_animal(self):
        pass

class DogFactory(AnimalFactory):
    def create_animal(self):
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self):
        return Cat()

# Client code
def get_animal(factory: AnimalFactory):
    animal = factory.create_animal()
    return animal.speak()


dog_sound = get_animal(DogFactory())
cat_sound = get_animal(CatFactory())

print(f"Hond zegt: {dog_sound}") # Output: Hond zegt: Woef!
print(f"Kat zegt: {cat_sound}") # Output: Kat zegt: Miauw!

Uitleg:

Animal: Een abstracte basisklasse die de interface voor alle diersoorten definieert.
Dog en Cat: Concrete klassen die de Animal interface implementeren.
AnimalFactory: Een abstracte basisklasse die de interface definieert voor het creëren van dieren.
DogFactory en CatFactory: Concrete klassen die de AnimalFactory interface implementeren, verantwoordelijk voor het creëren van respectievelijk Dog en Cat instanties.
get_animal: Een client-functie die de factory gebruikt om een dier te creëren en te gebruiken.

Gebruiksscenario's

UI Frameworks: Het creëren van platformspecifieke UI-elementen (bijv. knoppen, tekstvelden) met behulp van verschillende factories voor verschillende besturingssystemen.
Game Development: Het creëren van verschillende soorten gamekarakters of objecten op basis van spelniveau of gebruikersselectie.
Documentverwerking: Het creëren van verschillende soorten documenten (bijv. PDF, Word, HTML) met behulp van verschillende factories op basis van de gewenste uitvoerindeling.

Voorbeeld

Overweeg een scenario waarin u verschillende soorten betalingsmethoden wilt creëren op basis van gebruikersselectie. Hier is hoe u dit kunt implementeren met behulp van het Factory Method pattern:

            
from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

class CreditCardPayment(Payment):
    def process_payment(self, amount):
        return f"Verwerking creditcard betaling van ${amount}"

class PayPalPayment(Payment):
    def process_payment(self, amount):
        return f"Verwerking PayPal betaling van ${amount}"

class PaymentFactory(ABC):
    @abstractmethod
    def create_payment_method(self):
        pass

class CreditCardPaymentFactory(PaymentFactory):
    def create_payment_method(self):
        return CreditCardPayment()

class PayPalPaymentFactory(PaymentFactory):
    def create_payment_method(self):
        return PayPalPayment()

# Client code
def process_payment(factory: PaymentFactory, amount):
    payment_method = factory.create_payment_method()
    return payment_method.process_payment(amount)


credit_card_payment = process_payment(CreditCardPaymentFactory(), 100)
paypal_payment = process_payment(PayPalPaymentFactory(), 50)

print(credit_card_payment) # Output: Verwerking creditcard betaling van $100
print(paypal_payment) # Output: Verwerking PayPal betaling van $50

3. Abstract Factory Pattern

Het Abstract Factory pattern biedt een interface voor het creëren van families van gerelateerde of afhankelijke objecten zonder hun concrete klassen te specificeren. Hiermee kunt u objecten maken die zijn ontworpen om samen te werken, wat consistentie en compatibiliteit garandeert.

Implementatie

Hier is een Python-implementatie van het Abstract Factory pattern:

            
from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def paint(self):
        pass

class Checkbox(ABC):
    @abstractmethod
    def paint(self):
        pass

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self):
        pass

    @abstractmethod
    def create_checkbox(self):
        pass

class WinFactory(GUIFactory):
    def create_button(self):
        return WinButton()

    def create_checkbox(self):
        return WinCheckbox()

class MacFactory(GUIFactory):
    def create_button(self):
        return MacButton()

    def create_checkbox(self):
        return MacCheckbox()

class WinButton(Button):
    def paint(self):
        return "Renderen van een Windows-knop"

class MacButton(Button):
    def paint(self):
        return "Renderen van een Mac-knop"

class WinCheckbox(Checkbox):
    def paint(self):
        return "Renderen van een Windows-selectievakje"

class MacCheckbox(Checkbox):
    def paint(self):
        return "Renderen van een Mac-selectievakje"

# Client code
def paint_ui(factory: GUIFactory):
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    return button.paint(), checkbox.paint()

win_button, win_checkbox = paint_ui(WinFactory())
mac_button, mac_checkbox = paint_ui(MacFactory())

print(win_button) # Output: Renderen van een Windows-knop
print(win_checkbox) # Output: Renderen van een Windows-selectievakje
print(mac_button) # Output: Renderen van een Mac-knop
print(mac_checkbox) # Output: Renderen van een Mac-selectievakje

Uitleg:

Button en Checkbox: Abstracte basisklassen die de interfaces voor UI-elementen definiëren.
WinButton, MacButton, WinCheckbox en MacCheckbox: Concrete klassen die de UI-element interfaces implementeren voor Windows- en Mac-platforms.
GUIFactory: Een abstracte basisklasse die de interface definieert voor het creëren van families van UI-elementen.
WinFactory en MacFactory: Concrete klassen die de GUIFactory interface implementeren, verantwoordelijk voor het creëren van UI-elementen voor respectievelijk Windows- en Mac-platforms.
paint_ui: Een client-functie die de factory gebruikt om UI-elementen te creëren en te schilderen.

Gebruiksscenario's

UI Frameworks: Het creëren van UI-elementen die consistent zijn met het uiterlijk van een specifiek besturingssysteem of platform.
Game Development: Het creëren van game-objecten die consistent zijn met de stijl van een specifiek spelniveau of thema.
Data Access: Het creëren van data access objecten die compatibel zijn met een specifieke database of gegevensbron.

Voorbeeld

Overweeg een scenario waarin u verschillende soorten meubels (bijv. stoelen, tafels) met verschillende stijlen (bijv. modern, Victoriaans) wilt creëren. Hier is hoe u dit kunt implementeren met behulp van het Abstract Factory pattern:

            
from abc import ABC, abstractmethod

class Chair(ABC):
    @abstractmethod
    def create(self):
        pass

class Table(ABC):
    @abstractmethod
    def create(self):
        pass

class FurnitureFactory(ABC):
    @abstractmethod
    def create_chair(self):
        pass

    @abstractmethod
    def create_table(self):
        pass

class ModernFurnitureFactory(FurnitureFactory):
    def create_chair(self):
        return ModernChair()

    def create_table(self):
        return ModernTable()

class VictorianFurnitureFactory(FurnitureFactory):
    def create_chair(self):
        return VictorianChair()

    def create_table(self):
        return VictorianTable()

class ModernChair(Chair):
    def create(self):
        return "Een moderne stoel creëren"

class VictorianChair(Chair):
    def create(self):
        return "Een Victoriaanse stoel creëren"

class ModernTable(Table):
    def create(self):
        return "Een moderne tafel creëren"

class VictorianTable(Table):
    def create(self):
        return "Een Victoriaanse tafel creëren"

# Client code
def create_furniture(factory: FurnitureFactory):
    chair = factory.create_chair()
    table = factory.create_table()
    return chair.create(), table.create()


modern_chair, modern_table = create_furniture(ModernFurnitureFactory())
victorian_chair, victorian_table = create_furniture(VictorianFurnitureFactory())

print(modern_chair) # Output: Een moderne stoel creëren
print(modern_table) # Output: Een moderne tafel creëren
print(victorian_chair) # Output: Een Victoriaanse stoel creëren
print(victorian_table) # Output: Een Victoriaanse tafel creëren

4. Builder Pattern

Het Builder pattern scheidt de constructie van een complex object van zijn representatie, waardoor hetzelfde constructieproces verschillende representaties kan creëren. Het is handig wanneer u complexe objecten met meerdere optionele componenten moet creëren en wilt voorkomen dat u een groot aantal constructors of configuratieparameters maakt.

Implementatie

Hier is een Python-implementatie van het Builder pattern:

            
class Pizza:
    def __init__(self):
        self.dough = None
        self.sauce = None
        self.topping = None

    def __str__(self):
        return f"Pizza met deeg: {self.dough}, saus: {self.sauce} en topping: {self.topping}"

class PizzaBuilder:
    def __init__(self):
        self.pizza = Pizza()

    def set_dough(self, dough):
        self.pizza.dough = dough
        return self

    def set_sauce(self, sauce):
        self.pizza.sauce = sauce
        return self

    def set_topping(self, topping):
        self.pizza.topping = topping
        return self

    def build(self):
        return self.pizza

# Client code
pizza_builder = PizzaBuilder()
pizza = pizza_builder.set_dough("Dunne bodem").set_sauce("Tomaat").set_topping("Pepperoni").build()

print(pizza) # Output: Pizza met deeg: Dunne bodem, saus: Tomaat en topping: Pepperoni

Uitleg:

Pizza: Een klasse die het complexe object vertegenwoordigt dat moet worden gebouwd.
PizzaBuilder: Een builder klasse die methoden biedt voor het instellen van de verschillende componenten van het Pizza object.

Gebruiksscenario's

Documentgeneratie: Het creëren van complexe documenten (bijv. rapporten, facturen) met verschillende secties en opmaakopties.
Game Development: Het creëren van complexe game-objecten (bijv. karakters, niveaus) met verschillende attributen en componenten.
Gegevensverwerking: Het creëren van complexe datastructuren (bijv. grafieken, bomen) met verschillende knooppunten en relaties.

Voorbeeld

Overweeg een scenario waarin u verschillende soorten computers wilt bouwen met verschillende componenten (bijv. CPU, RAM, opslag). Hier is hoe u dit kunt implementeren met behulp van het Builder pattern:

            
class Computer:
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.storage = None
        self.graphics_card = None

    def __str__(self):
        return f"Computer met CPU: {self.cpu}, RAM: {self.ram}, Opslag: {self.storage}, Grafische kaart: {self.graphics_card}"

class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()

    def set_cpu(self, cpu):
        self.computer.cpu = cpu
        return self

    def set_ram(self, ram):
        self.computer.ram = ram
        return self

    def set_storage(self, storage):
        self.computer.storage = storage
        return self

    def set_graphics_card(self, graphics_card):
        self.computer.graphics_card = graphics_card
        return self

    def build(self):
        return self.computer

# Client code
computer_builder = ComputerBuilder()
computer = computer_builder.set_cpu("Intel i7").set_ram("16GB").set_storage("1TB SSD").set_graphics_card("Nvidia RTX 3080").build()

print(computer)
# Output: Computer met CPU: Intel i7, RAM: 16GB, Opslag: 1TB SSD, Grafische kaart: Nvidia RTX 3080

5. Prototype Pattern

Het Prototype pattern specificeert het soort objecten dat moet worden gemaakt met behulp van een prototypische instantie en creëert nieuwe objecten door dit prototype te kopiëren. Hiermee kunt u nieuwe objecten maken door een bestaand object te klonen, waardoor de noodzaak wordt vermeden om objecten vanaf nul te creëren. Dit kan handig zijn als het maken van objecten duur of complex is.

Implementatie

Hier is een Python-implementatie van het Prototype pattern:

            
import copy

class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        self._objects[name] = obj

    def unregister_object(self, name):
        del self._objects[name]

    def clone(self, name, **attrs):
        obj = copy.deepcopy(self._objects.get(name))
        if attrs:
            obj.__dict__.update(attrs)
        return obj

class Car:
    def __init__(self):
        self.name = ""
        self.color = ""
        self.options = []

    def __str__(self):
        return f"Auto: Naam={self.name}, Kleur={self.color}, Opties={self.options}"

# Client code
prototype = Prototype()
car = Car()
car.name = "Generieke Auto"
car.color = "Wit"
car.options = ["AC", "GPS"]

prototype.register_object("generiek", car)

car1 = prototype.clone("generiek", name="Sportwagen", color="Rood", options=["AC", "GPS", "Spoiler"])
car2 = prototype.clone("generiek", name="Gezinsauto", color="Blauw", options=["AC", "GPS", "Dakluik"])

print(car1)
# Output: Auto: Naam=Sportwagen, Kleur=Rood, Opties=['AC', 'GPS', 'Spoiler']
print(car2)
# Output: Auto: Naam=Gezinsauto, Kleur=Blauw, Opties=['AC', 'GPS', 'Dakluik']

Uitleg:

Prototype: Een klasse die de prototypes beheert en een methode biedt om ze te klonen.
Car: Een klasse die het te klonen object vertegenwoordigt.

Gebruiksscenario's

Game Development: Het creëren van game-objecten die vergelijkbaar zijn met elkaar, zoals vijanden of power-ups.
Documentverwerking: Het creëren van documenten die gebaseerd zijn op een sjabloon.
Configuratiebeheer: Het creëren van configuratie-objecten die gebaseerd zijn op een standaard configuratie.

Voorbeeld

Overweeg een scenario waarin u verschillende soorten werknemers wilt creëren met verschillende attributen (bijv. naam, functie, afdeling). Hier is hoe u dit kunt implementeren met behulp van het Prototype pattern:

            
import copy

class Employee:
    def __init__(self):
        self.name = None
        self.role = None
        self.department = None

    def __str__(self):
        return f"Werknemer: Naam={self.name}, Functie={self.role}, Afdeling={self.department}"

class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        self._objects[name] = obj

    def unregister_object(self, name):
        del self._objects[name]

    def clone(self, name, **attrs):
        obj = copy.deepcopy(self._objects.get(name))
        if attrs:
            obj.__dict__.update(attrs)
        return obj


# Client code
prototype = Prototype()
employee = Employee()
employee.name = "Generieke Werknemer"
employee.role = "Ontwikkelaar"
employee.department = "IT"

prototype.register_object("generiek", employee)

employee1 = prototype.clone("generiek", name="John Doe", role="Senior Ontwikkelaar")
employee2 = prototype.clone("generiek", name="Jane Smith", role="Project Manager", department="Management")

print(employee1)
# Output: Werknemer: Naam=John Doe, Functie=Senior Ontwikkelaar, Afdeling=IT
print(employee2)
# Output: Werknemer: Naam=Jane Smith, Functie=Project Manager, Afdeling=Management

Conclusie

Creational design patterns bieden krachtige tools voor het beheren van object creatie op een flexibele en onderhoudbare manier. Door deze patronen te begrijpen en toe te passen, kunt u schonere, robuustere code schrijven die gemakkelijker uit te breiden is en aan te passen is aan veranderende eisen. Dit artikel heeft vijf belangrijke creational patterns onderzocht: Singleton, Factory Method, Abstract Factory, Builder en Prototype, met praktische voorbeelden en real-world use cases. Het beheersen van deze patronen is een essentiële stap om een vaardige Python-ontwikkelaar te worden.

Onthoud dat het kiezen van het juiste patroon afhangt van het specifieke probleem dat u probeert op te lossen. Overweeg de complexiteit van object creatie, de behoefte aan flexibiliteit en de mogelijkheden voor toekomstige veranderingen bij het selecteren van een creational pattern voor uw project. Door dit te doen, kunt u de kracht van design patterns benutten om elegante en efficiënte oplossingen te creëren voor veelvoorkomende software design uitdagingen.